home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / BankSmakow.air / BankSmakow.swf / scripts / mx / modules / ModuleManager.as < prev    next >
Text File  |  2009-12-16  |  16KB  |  610 lines
  1. package mx.modules
  2. {
  3.    import mx.core.IFlexModuleFactory;
  4.    import mx.core.mx_internal;
  5.    
  6.    use namespace mx_internal;
  7.    
  8.    public class ModuleManager
  9.    {
  10.       
  11.       mx_internal static const VERSION:String = "3.5.0.12683";
  12.        
  13.       
  14.       public function ModuleManager()
  15.       {
  16.          super();
  17.       }
  18.       
  19.       public static function getModule(param1:String) : IModuleInfo
  20.       {
  21.          return getSingleton().getModule(param1);
  22.       }
  23.       
  24.       private static function getSingleton() : Object
  25.       {
  26.          if(!ModuleManagerGlobals.managerSingleton)
  27.          {
  28.             ModuleManagerGlobals.managerSingleton = new ModuleManagerImpl();
  29.          }
  30.          return ModuleManagerGlobals.managerSingleton;
  31.       }
  32.       
  33.       public static function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  34.       {
  35.          return getSingleton().getAssociatedFactory(param1);
  36.       }
  37.    }
  38. }
  39.  
  40. import flash.events.EventDispatcher;
  41. import flash.system.ApplicationDomain;
  42. import flash.system.SecurityDomain;
  43. import flash.utils.ByteArray;
  44. import mx.core.IFlexModuleFactory;
  45. import mx.events.ModuleEvent;
  46. import mx.modules.IModuleInfo;
  47.  
  48. class ModuleInfoProxy extends EventDispatcher implements IModuleInfo
  49. {
  50.     
  51.    
  52.    private var _data:Object;
  53.    
  54.    private var info:ModuleInfo;
  55.    
  56.    private var referenced:Boolean = false;
  57.    
  58.    function ModuleInfoProxy(param1:ModuleInfo)
  59.    {
  60.       super();
  61.       this.info = param1;
  62.       param1.addEventListener(ModuleEvent.SETUP,moduleEventHandler,false,0,true);
  63.       param1.addEventListener(ModuleEvent.PROGRESS,moduleEventHandler,false,0,true);
  64.       param1.addEventListener(ModuleEvent.READY,moduleEventHandler,false,0,true);
  65.       param1.addEventListener(ModuleEvent.ERROR,moduleEventHandler,false,0,true);
  66.       param1.addEventListener(ModuleEvent.UNLOAD,moduleEventHandler,false,0,true);
  67.    }
  68.    
  69.    public function get loaded() : Boolean
  70.    {
  71.       return info.loaded;
  72.    }
  73.    
  74.    public function release() : void
  75.    {
  76.       if(referenced)
  77.       {
  78.          info.removeReference();
  79.          referenced = false;
  80.       }
  81.    }
  82.    
  83.    public function get error() : Boolean
  84.    {
  85.       return info.error;
  86.    }
  87.    
  88.    public function get factory() : IFlexModuleFactory
  89.    {
  90.       return info.factory;
  91.    }
  92.    
  93.    public function publish(param1:IFlexModuleFactory) : void
  94.    {
  95.       info.publish(param1);
  96.    }
  97.    
  98.    public function set data(param1:Object) : void
  99.    {
  100.       _data = param1;
  101.    }
  102.    
  103.    public function get ready() : Boolean
  104.    {
  105.       return info.ready;
  106.    }
  107.    
  108.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null, param3:ByteArray = null) : void
  109.    {
  110.       var _loc4_:ModuleEvent = null;
  111.       info.resurrect();
  112.       if(!referenced)
  113.       {
  114.          info.addReference();
  115.          referenced = true;
  116.       }
  117.       if(info.error)
  118.       {
  119.          dispatchEvent(new ModuleEvent(ModuleEvent.ERROR));
  120.       }
  121.       else if(info.loaded)
  122.       {
  123.          if(info.setup)
  124.          {
  125.             dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  126.             if(info.ready)
  127.             {
  128.                (_loc4_ = new ModuleEvent(ModuleEvent.PROGRESS)).bytesLoaded = info.size;
  129.                _loc4_.bytesTotal = info.size;
  130.                dispatchEvent(_loc4_);
  131.                dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  132.             }
  133.          }
  134.       }
  135.       else
  136.       {
  137.          info.load(param1,param2,param3);
  138.       }
  139.    }
  140.    
  141.    private function moduleEventHandler(param1:ModuleEvent) : void
  142.    {
  143.       dispatchEvent(param1);
  144.    }
  145.    
  146.    public function get url() : String
  147.    {
  148.       return info.url;
  149.    }
  150.    
  151.    public function get data() : Object
  152.    {
  153.       return _data;
  154.    }
  155.    
  156.    public function get setup() : Boolean
  157.    {
  158.       return info.setup;
  159.    }
  160.    
  161.    public function unload() : void
  162.    {
  163.       info.unload();
  164.       info.removeEventListener(ModuleEvent.SETUP,moduleEventHandler);
  165.       info.removeEventListener(ModuleEvent.PROGRESS,moduleEventHandler);
  166.       info.removeEventListener(ModuleEvent.READY,moduleEventHandler);
  167.       info.removeEventListener(ModuleEvent.ERROR,moduleEventHandler);
  168.       info.removeEventListener(ModuleEvent.UNLOAD,moduleEventHandler);
  169.    }
  170. }
  171.  
  172. import flash.events.EventDispatcher;
  173. import flash.system.ApplicationDomain;
  174. import flash.utils.getQualifiedClassName;
  175. import mx.core.IFlexModuleFactory;
  176. import mx.modules.IModuleInfo;
  177.  
  178. class ModuleManagerImpl extends EventDispatcher
  179. {
  180.     
  181.    
  182.    private var moduleList:Object;
  183.    
  184.    function ModuleManagerImpl()
  185.    {
  186.       moduleList = {};
  187.       super();
  188.    }
  189.    
  190.    public function getModule(param1:String) : IModuleInfo
  191.    {
  192.       var _loc2_:ModuleInfo = moduleList[param1] as ModuleInfo;
  193.       if(!_loc2_)
  194.       {
  195.          _loc2_ = new ModuleInfo(param1);
  196.          moduleList[param1] = _loc2_;
  197.       }
  198.       return new ModuleInfoProxy(_loc2_);
  199.    }
  200.    
  201.    public function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  202.    {
  203.       var m:Object = null;
  204.       var info:ModuleInfo = null;
  205.       var domain:ApplicationDomain = null;
  206.       var cls:Class = null;
  207.       var object:Object = param1;
  208.       var className:String = getQualifiedClassName(object);
  209.       for each(m in moduleList)
  210.       {
  211.          info = m as ModuleInfo;
  212.          if(info.ready)
  213.          {
  214.             domain = info.applicationDomain;
  215.             try
  216.             {
  217.                cls = Class(domain.getDefinition(className));
  218.                if(object is cls)
  219.                {
  220.                   return info.factory;
  221.                }
  222.             }
  223.             catch(error:Error)
  224.             {
  225.                continue;
  226.             }
  227.          }
  228.       }
  229.       return null;
  230.    }
  231. }
  232.  
  233. import flash.display.Loader;
  234. import flash.events.ErrorEvent;
  235. import flash.events.Event;
  236. import flash.events.EventDispatcher;
  237. import flash.events.IOErrorEvent;
  238. import flash.events.ProgressEvent;
  239. import flash.events.SecurityErrorEvent;
  240. import flash.net.URLRequest;
  241. import flash.system.ApplicationDomain;
  242. import flash.system.LoaderContext;
  243. import flash.system.Security;
  244. import flash.system.SecurityDomain;
  245. import flash.utils.ByteArray;
  246. import flash.utils.Dictionary;
  247. import mx.core.IFlexModuleFactory;
  248. import mx.events.ModuleEvent;
  249.  
  250. class ModuleInfo extends EventDispatcher
  251. {
  252.     
  253.    
  254.    private var _error:Boolean = false;
  255.    
  256.    private var loader:Loader;
  257.    
  258.    private var factoryInfo:FactoryInfo;
  259.    
  260.    private var limbo:Dictionary;
  261.    
  262.    private var _loaded:Boolean = false;
  263.    
  264.    private var _ready:Boolean = false;
  265.    
  266.    private var numReferences:int = 0;
  267.    
  268.    private var _url:String;
  269.    
  270.    private var _setup:Boolean = false;
  271.    
  272.    function ModuleInfo(param1:String)
  273.    {
  274.       super();
  275.       _url = param1;
  276.    }
  277.    
  278.    private function clearLoader() : void
  279.    {
  280.       if(loader)
  281.       {
  282.          if(loader.contentLoaderInfo)
  283.          {
  284.             loader.contentLoaderInfo.removeEventListener(Event.INIT,initHandler);
  285.             loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,completeHandler);
  286.             loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  287.             loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  288.             loader.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  289.          }
  290.          try
  291.          {
  292.             if(loader.content)
  293.             {
  294.                loader.content.removeEventListener("ready",readyHandler);
  295.                loader.content.removeEventListener("error",moduleErrorHandler);
  296.             }
  297.          }
  298.          catch(error:Error)
  299.          {
  300.          }
  301.          if(_loaded)
  302.          {
  303.             try
  304.             {
  305.                loader.close();
  306.             }
  307.             catch(error:Error)
  308.             {
  309.             }
  310.          }
  311.          try
  312.          {
  313.             loader.unload();
  314.          }
  315.          catch(error:Error)
  316.          {
  317.          }
  318.          loader = null;
  319.       }
  320.    }
  321.    
  322.    public function get size() : int
  323.    {
  324.       return !limbo && factoryInfo ? int(factoryInfo.bytesTotal) : 0;
  325.    }
  326.    
  327.    public function get loaded() : Boolean
  328.    {
  329.       return !limbo ? Boolean(_loaded) : false;
  330.    }
  331.    
  332.    public function release() : void
  333.    {
  334.       if(_ready && !limbo)
  335.       {
  336.          limbo = new Dictionary(true);
  337.          limbo[factoryInfo] = 1;
  338.          factoryInfo = null;
  339.       }
  340.       else
  341.       {
  342.          unload();
  343.       }
  344.    }
  345.    
  346.    public function get error() : Boolean
  347.    {
  348.       return !limbo ? Boolean(_error) : false;
  349.    }
  350.    
  351.    public function get factory() : IFlexModuleFactory
  352.    {
  353.       return !limbo && factoryInfo ? factoryInfo.factory : null;
  354.    }
  355.    
  356.    public function completeHandler(param1:Event) : void
  357.    {
  358.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  359.       _loc2_.bytesLoaded = loader.contentLoaderInfo.bytesLoaded;
  360.       _loc2_.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  361.       dispatchEvent(_loc2_);
  362.    }
  363.    
  364.    public function publish(param1:IFlexModuleFactory) : void
  365.    {
  366.       if(factoryInfo)
  367.       {
  368.          return;
  369.       }
  370.       if(_url.indexOf("published://") != 0)
  371.       {
  372.          return;
  373.       }
  374.       factoryInfo = new FactoryInfo();
  375.       factoryInfo.factory = param1;
  376.       _loaded = true;
  377.       _setup = true;
  378.       _ready = true;
  379.       _error = false;
  380.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  381.       dispatchEvent(new ModuleEvent(ModuleEvent.PROGRESS));
  382.       dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  383.    }
  384.    
  385.    public function initHandler(param1:Event) : void
  386.    {
  387.       var moduleEvent:ModuleEvent = null;
  388.       var event:Event = param1;
  389.       factoryInfo = new FactoryInfo();
  390.       try
  391.       {
  392.          factoryInfo.factory = loader.content as IFlexModuleFactory;
  393.       }
  394.       catch(error:Error)
  395.       {
  396.       }
  397.       if(!factoryInfo.factory)
  398.       {
  399.          moduleEvent = new ModuleEvent(ModuleEvent.ERROR,event.bubbles,event.cancelable);
  400.          moduleEvent.bytesLoaded = 0;
  401.          moduleEvent.bytesTotal = 0;
  402.          moduleEvent.errorText = "SWF is not a loadable module";
  403.          dispatchEvent(moduleEvent);
  404.          return;
  405.       }
  406.       loader.content.addEventListener("ready",readyHandler);
  407.       loader.content.addEventListener("error",moduleErrorHandler);
  408.       try
  409.       {
  410.          factoryInfo.applicationDomain = loader.contentLoaderInfo.applicationDomain;
  411.       }
  412.       catch(error:Error)
  413.       {
  414.       }
  415.       _setup = true;
  416.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  417.    }
  418.    
  419.    public function resurrect() : void
  420.    {
  421.       var _loc1_:* = null;
  422.       if(!factoryInfo && limbo)
  423.       {
  424.          var _loc2_:int = 0;
  425.          var _loc3_:* = limbo;
  426.          for(_loc1_ in _loc3_)
  427.          {
  428.             factoryInfo = _loc1_ as FactoryInfo;
  429.          }
  430.          limbo = null;
  431.       }
  432.       if(!factoryInfo)
  433.       {
  434.          if(_loaded)
  435.          {
  436.             dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  437.          }
  438.          loader = null;
  439.          _loaded = false;
  440.          _setup = false;
  441.          _ready = false;
  442.          _error = false;
  443.       }
  444.    }
  445.    
  446.    public function errorHandler(param1:ErrorEvent) : void
  447.    {
  448.       _error = true;
  449.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.ERROR,param1.bubbles,param1.cancelable);
  450.       _loc2_.bytesLoaded = 0;
  451.       _loc2_.bytesTotal = 0;
  452.       _loc2_.errorText = param1.text;
  453.       dispatchEvent(_loc2_);
  454.    }
  455.    
  456.    public function get ready() : Boolean
  457.    {
  458.       return !limbo ? Boolean(_ready) : false;
  459.    }
  460.    
  461.    private function loadBytes(param1:ApplicationDomain, param2:ByteArray) : void
  462.    {
  463.       var _loc3_:LoaderContext = new LoaderContext();
  464.       _loc3_.applicationDomain = !!param1 ? param1 : new ApplicationDomain(ApplicationDomain.currentDomain);
  465.       if("allowLoadBytesCodeExecution" in _loc3_)
  466.       {
  467.          _loc3_["allowLoadBytesCodeExecution"] = true;
  468.       }
  469.       loader = new Loader();
  470.       loader.contentLoaderInfo.addEventListener(Event.INIT,initHandler);
  471.       loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
  472.       loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  473.       loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  474.       loader.loadBytes(param2,_loc3_);
  475.    }
  476.    
  477.    public function removeReference() : void
  478.    {
  479.       --numReferences;
  480.       if(numReferences == 0)
  481.       {
  482.          release();
  483.       }
  484.    }
  485.    
  486.    public function addReference() : void
  487.    {
  488.       ++numReferences;
  489.    }
  490.    
  491.    public function progressHandler(param1:ProgressEvent) : void
  492.    {
  493.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  494.       _loc2_.bytesLoaded = param1.bytesLoaded;
  495.       _loc2_.bytesTotal = param1.bytesTotal;
  496.       dispatchEvent(_loc2_);
  497.    }
  498.    
  499.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null, param3:ByteArray = null) : void
  500.    {
  501.       if(_loaded)
  502.       {
  503.          return;
  504.       }
  505.       _loaded = true;
  506.       limbo = null;
  507.       if(param3)
  508.       {
  509.          loadBytes(param1,param3);
  510.          return;
  511.       }
  512.       if(_url.indexOf("published://") == 0)
  513.       {
  514.          return;
  515.       }
  516.       var _loc4_:URLRequest = new URLRequest(_url);
  517.       var _loc5_:LoaderContext;
  518.       (_loc5_ = new LoaderContext()).applicationDomain = !!param1 ? param1 : new ApplicationDomain(ApplicationDomain.currentDomain);
  519.       _loc5_.securityDomain = param2;
  520.       if(param2 == null && Security.sandboxType == Security.REMOTE)
  521.       {
  522.          _loc5_.securityDomain = SecurityDomain.currentDomain;
  523.       }
  524.       loader = new Loader();
  525.       loader.contentLoaderInfo.addEventListener(Event.INIT,initHandler);
  526.       loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
  527.       loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  528.       loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  529.       loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  530.       loader.load(_loc4_,_loc5_);
  531.    }
  532.    
  533.    public function get url() : String
  534.    {
  535.       return _url;
  536.    }
  537.    
  538.    public function get applicationDomain() : ApplicationDomain
  539.    {
  540.       return !limbo && factoryInfo ? factoryInfo.applicationDomain : null;
  541.    }
  542.    
  543.    public function moduleErrorHandler(param1:Event) : void
  544.    {
  545.       var _loc2_:ModuleEvent = null;
  546.       _ready = true;
  547.       factoryInfo.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  548.       clearLoader();
  549.       if(param1 is ModuleEvent)
  550.       {
  551.          _loc2_ = ModuleEvent(param1);
  552.       }
  553.       else
  554.       {
  555.          _loc2_ = new ModuleEvent(ModuleEvent.ERROR);
  556.       }
  557.       dispatchEvent(_loc2_);
  558.    }
  559.    
  560.    public function readyHandler(param1:Event) : void
  561.    {
  562.       _ready = true;
  563.       factoryInfo.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  564.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.READY);
  565.       _loc2_.bytesLoaded = loader.contentLoaderInfo.bytesLoaded;
  566.       _loc2_.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  567.       clearLoader();
  568.       dispatchEvent(_loc2_);
  569.    }
  570.    
  571.    public function get setup() : Boolean
  572.    {
  573.       return !limbo ? Boolean(_setup) : false;
  574.    }
  575.    
  576.    public function unload() : void
  577.    {
  578.       clearLoader();
  579.       if(_loaded)
  580.       {
  581.          dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  582.       }
  583.       limbo = null;
  584.       factoryInfo = null;
  585.       _loaded = false;
  586.       _setup = false;
  587.       _ready = false;
  588.       _error = false;
  589.    }
  590. }
  591.  
  592. import flash.system.ApplicationDomain;
  593. import mx.core.IFlexModuleFactory;
  594.  
  595. class FactoryInfo
  596. {
  597.     
  598.    
  599.    public var bytesTotal:int = 0;
  600.    
  601.    public var factory:IFlexModuleFactory;
  602.    
  603.    public var applicationDomain:ApplicationDomain;
  604.    
  605.    function FactoryInfo()
  606.    {
  607.       super();
  608.    }
  609. }
  610.